////////////////////////////////////////////
// 全局变量定义 - 修复版本
////////////////////////////////////////////

// 确保这些变量在文件最顶部定义
var lastMessageId = 0;
var currentSessionId = null;
var existingSessions = new Set();
var isSwitchingSession = false;

// 其他现有变量
var friendRequestsCount = 0;
var friendOnlineStatus = new Map();
var currentUser = null;
var websocket = null;
var sessions = new Map();
var webSocket = null;
var isConnected = false;

// 消息去重相关
var displayedMessages = {};

////////////////////////////////////////////
// 页面加载完成后的初始化
////////////////////////////////////////////
document.addEventListener('DOMContentLoaded', function() {
    // 显示加载动画
    showLoadingScreen();
    
    console.log('开始初始化聊天室...');
    
    // 设置一个最大超时，防止无限加载
    const maxLoadTime = 10000; // 10秒
    const loadTimer = setTimeout(() => {
        console.error('页面加载超时，强制进入页面');
        hideLoadingScreen();
    }, maxLoadTime);


    // 确保所有必需函数都存在
    if (typeof updateChatTitle === 'undefined') {
        console.warn('updateChatTitle 未定义，正在创建默认实现');
        window.updateChatTitle = function(userName) {
            let chatTitle = document.getElementById('chat-title');
            if (chatTitle) {
                chatTitle.innerHTML = `<span>与 ${userName} 的对话</span>`;
            }
        };
    }

    // 初始化全局变量
    if (typeof lastMessageId === 'undefined') window.lastMessageId = 0;
    if (typeof currentSessionId === 'undefined') window.currentSessionId = null;
    if (typeof existingSessions === 'undefined') window.existingSessions = new Set();
    if (typeof isSwitchingSession === 'undefined') window.isSwitchingSession = false;
    if (typeof displayedMessages === 'undefined') window.displayedMessages = {};

    try {
        // 初始化核心功能
        initInputAndSend();
        initSwitchTab();
        initWebSocket();
        initEmojiPanel();
        initFileUpload();
        initFriendFeatures();
        initSearchFeature(); // 新增：初始化搜索功能
        
        // 获取用户信息
        getUserInfo();
        
        // 初始化好友功能（延迟执行，避免阻塞）
        setTimeout(() => {
            try {
                initFriendFeatures();
            } catch (error) {
                console.error('初始化好友功能失败:', error);
            }
        }, 1000);
        
        // 正常初始化完成后，清除超时定时器并隐藏加载动画
        setTimeout(() => {
            clearTimeout(loadTimer);
            hideLoadingScreen();
            console.log('聊天室初始化完成');
        }, 2000);
        
    } catch (error) {
        console.error('初始化过程中发生错误:', error);
        clearTimeout(loadTimer);
        hideLoadingScreen();
        showNotification('初始化失败，请刷新页面', 'error');
    }
});


// 增强的会话检查函数 - 确保不会重复创建会话
function checkExistingSessionByFriendId(friendId) {
    console.log('严格检查好友ID对应的会话:', friendId);
    
    // 方法1：检查内存中的会话
    for (let [sessionId, sessionInfo] of sessions) {
        console.log(`检查内存会话 ${sessionId}:`, sessionInfo);
        if (sessionInfo.friendId && sessionInfo.friendId.toString() === friendId.toString()) {
            console.log('在内存中找到匹配的会话:', sessionId);
            return sessionId;
        }
    }
    
    // 方法2：检查DOM中的会话项
    let sessionLi = findSessionLiByFriendId(friendId);
    if (sessionLi) {
        const sessionId = sessionLi.getAttribute('data-session-id');
        console.log('在DOM中找到匹配的会话:', sessionId);
        
        // 如果会话信息不在内存中，重新创建会话信息
        if (!sessions.has(sessionId)) {
            const userName = sessionLi.querySelector('.name').textContent;
            const lastMessage = sessionLi.querySelector('.last-message').textContent;
            sessions.set(sessionId, {
                sessionId: sessionId,
                userName: userName,
                friendId: friendId,
                lastMessage: lastMessage,
                lastMessageTime: new Date()
            });
        }
        
        return sessionId;
    }
    
    // 方法3：检查服务器会话列表（如果需要）
    console.log('未找到好友对应的现有会话');
    return null;
}

// 统一的会话创建入口函数
// 更新统一的会话创建入口函数
function createOrSwitchToSession(friend) {
    console.log('创建或切换到会话，好友:', friend);
    
    // 严格检查现有会话
    const existingSessionId = checkExistingSessionByFriendId(friend.friendId);
    
    if (existingSessionId) {
        console.log('找到现有会话，切换到:', existingSessionId);
        const sessionInfo = sessions.get(existingSessionId);
        if (sessionInfo) {
            switchToSession(existingSessionId, sessionInfo.userName);
            showNotification(`已切换到与 ${friend.friendName} 的对话`, 'success');
        } else {
            console.error('会话信息丢失，重新创建');
            return createSessionWithLock(friend);
        }
        return Promise.resolve(existingSessionId);
    } else {
        console.log('未找到现有会话，创建新会话');
        return createSessionWithLock(friend);
    }
}
// 通过好友ID查找会话项 - 确保这个函数存在
function findSessionLiByFriendId(friendId) {
    let sessionItems = document.querySelectorAll('#session-list li');
    for (let item of sessionItems) {
        let itemFriendId = item.getAttribute('data-friend-id');
        if (itemFriendId && itemFriendId.toString() === friendId.toString()) {
            return item;
        }
    }
    return null;
}

////////////////////////////////////////////
// 好友搜索功能
////////////////////////////////////////////

function initSearchFeature() {
    console.log('初始化搜索功能...');
    
    const searchInput = document.getElementById('search-friend-input');
    const searchButton = document.getElementById('search-friend-btn');
    const searchResultsPanel = document.getElementById('search-results-panel');
    const closeSearchResults = document.getElementById('close-search-results');
    
    if (!searchInput || !searchButton || !searchResultsPanel) {
        console.error('搜索功能所需的元素未找到');
        return;
    }
    
    let searchTimeout = null;
    
    // 搜索按钮点击事件
    searchButton.addEventListener('click', function(e) {
        e.preventDefault();
        e.stopPropagation();
        performSearch();
    });
    
    // 输入框输入事件（实时搜索）
    searchInput.addEventListener('input', function() {
        // 清除之前的定时器
        if (searchTimeout) {
            clearTimeout(searchTimeout);
        }
        
        // 设置新的定时器，实现防抖
        searchTimeout = setTimeout(() => {
            const query = this.value.trim();
            if (query.length >= 1) {
                performSearch();
            } else {
                hideSearchResults();
            }
        }, 300);
    });
    
    // 修复：关闭搜索结果
    closeSearchResults.addEventListener('click', function(e) {
        e.preventDefault();
        e.stopPropagation();
        console.log('关闭搜索结果面板');
        hideSearchResults();
        searchInput.value = '';
    });
    
    // 点击页面其他地方关闭搜索结果
    document.addEventListener('click', function(e) {
        const isSearchInput = e.target === searchInput;
        const isSearchButton = e.target === searchButton || searchButton.contains(e.target);
        const isSearchPanel = searchResultsPanel.contains(e.target);
        
        if (!isSearchInput && !isSearchButton && !isSearchPanel) {
            hideSearchResults();
        }
    });
    
    // 阻止搜索框区域的点击事件冒泡
    const searchContainer = document.querySelector('.search');
    if (searchContainer) {
        searchContainer.addEventListener('click', function(e) {
            e.stopPropagation();
        });
    }
    
    console.log('搜索功能初始化完成');
}

// 执行搜索
function performSearch() {
    const searchInput = document.getElementById('search-friend-input');
    const query = searchInput.value.trim();
    
    if (!query) {
        showNotification('请输入要搜索的好友名称', 'warning');
        hideSearchResults();
        return;
    }
    
    console.log('执行好友搜索，关键词:', query);
    
    // 显示加载状态
    showSearchLoading();
    
    // 发送搜索请求到服务器 - 使用 findFriends API 搜索当前用户已有好友
    $.ajax({
        type: 'GET',
        url: '/findFriends?keyword=' + encodeURIComponent(query),
        success: function(response) {
            console.log('搜索成功，结果:', response);
            if (response && response.success) {
                displaySearchResults(response.data);
            } else {
                console.error('搜索失败:', response.message);
                showNotification('搜索失败: ' + (response.message || '未知错误'), 'error');
                displaySearchError();
            }
        },
        error: function(xhr, status, error) {
            console.error('搜索失败:', error);
            showNotification('搜索失败: ' + (xhr.responseText || error), 'error');
            displaySearchError();
        }
    });
}


// 显示搜索加载状态
function showSearchLoading() {
    const searchResultsList = document.getElementById('search-results-list');
    const searchResultsPanel = document.getElementById('search-results-panel');
    
    searchResultsList.innerHTML = `
        <div class="search-loading">
            <i class="fas fa-spinner fa-spin" style="margin-right: 8px;"></i>
            搜索中...
        </div>
    `;
    
    showSearchResults();
}

// 显示搜索结果
function displaySearchResults(results) {
    const searchResultsList = document.getElementById('search-results-list');
    const searchInput = document.getElementById('search-friend-input');
    const query = searchInput.value.trim();
    
    // 清空之前的结果
    searchResultsList.innerHTML = '';
    
    // 检查results是否为数组
    if (!Array.isArray(results)) {
        console.error('搜索结果不是数组:', results);
        searchResultsList.innerHTML = `
            <div class="no-results">
                搜索结果格式错误
            </div>
        `;
        showSearchResults();
        return;
    }

    if (results.length === 0) {
        searchResultsList.innerHTML = `
            <div class="no-results">
                未找到与"${query}"相关的好友
            </div>
        `;
        showSearchResults();
        return;
    }
    
    // 显示搜索结果
    results.forEach(friend => {
        const listItem = createSearchResultItem(friend);
        searchResultsList.appendChild(listItem);
    });
    
    showSearchResults();
}

// 创建搜索结果项
function createSearchResultItem(friend) {
    const li = document.createElement('li');
    li.className = 'search-result-item';
    
    // 获取头像首字母
    const avatarText = friend.friendName ? friend.friendName.charAt(0).toUpperCase() : '?';
    
    li.innerHTML = `
        <div class="search-result-avatar">${avatarText}</div>
        <div class="search-result-info">
            <div class="search-result-name">${friend.friendName || '未知用户'}</div>
            <div class="search-result-status">点击开始聊天</div>
        </div>
    `;
    
    // 点击搜索结果项
    li.addEventListener('click', function(e) {
        e.preventDefault();
        e.stopPropagation();
        handleSearchResultClick(friend);
    });
    
    return li;
}

// 修复 handleSearchResultClick 函数中的会话创建
function handleSearchResultClick(friend) {
    console.log('点击搜索结果:', friend);
    
    // 立即隐藏搜索结果面板
    hideSearchResults();
    
    // 清空搜索框
    const searchInput = document.getElementById('search-friend-input');
    searchInput.value = '';
    
    // 使用统一的会话创建函数
    createOrSwitchToSession(friend);
}

// 简化 createNewSessionFromSearch 函数
function createNewSessionFromSearch(friend) {
    console.log('从搜索结果创建会话，好友:', friend);
    
    // 立即隐藏搜索结果面板
    hideSearchResults();
    
    // 清空搜索框
    const searchInput = document.getElementById('search-friend-input');
    searchInput.value = '';
    
    // 使用统一的会话创建函数
    createOrSwitchToSession(friend);
}

// 实际的会话创建逻辑 - 增强版本
function actuallyCreateNewSession(friend) {
    console.log('实际创建新会话，好友:', friend);
    
    // 再次严格检查，防止竞态条件
    const finalCheckSessionId = checkExistingSessionByFriendId(friend.friendId);
    if (finalCheckSessionId) {
        console.log('最终检查发现现有会话，切换到:', finalCheckSessionId);
        const sessionInfo = sessions.get(finalCheckSessionId);
        if (sessionInfo) {
            switchToSession(finalCheckSessionId, sessionInfo.userName);
            showNotification(`已切换到与 ${friend.friendName} 的对话`, 'success');
        }
        return finalCheckSessionId;
    }
    
    showNotification(`正在创建与 ${friend.friendName} 的会话...`, 'info');
    
    return new Promise((resolve, reject) => {
        $.ajax({
            url: '/session',
            type: 'POST',
            data: { toUserId: friend.friendId },
            dataType: 'json',
            success: function(data) {
                console.log('后端返回数据:', data);
                
                if (data && data.sessionId) {
                    const sessionId = data.sessionId.toString();
                    
                    // 最终检查：防止在请求过程中其他操作创建了会话
                    const duplicateSessionId = checkExistingSessionByFriendId(friend.friendId);
                    if (duplicateSessionId && duplicateSessionId !== sessionId) {
                        console.log('检测到重复会话，使用现有会话:', duplicateSessionId);
                        const sessionInfo = sessions.get(duplicateSessionId);
                        if (sessionInfo) {
                            switchToSession(duplicateSessionId, sessionInfo.userName);
                            showNotification(`已切换到与 ${friend.friendName} 的对话`, 'success');
                            resolve(duplicateSessionId);
                        }
                        return;
                    }
                    
                    console.log('会话创建成功，sessionId:', sessionId);
                    
                    // 存储会话信息
                    sessions.set(sessionId, {
                        sessionId: sessionId,
                        userName: friend.friendName,
                        friendId: friend.friendId,
                        lastMessage: '开始聊天吧！',
                        lastMessageTime: new Date()
                    });
                    
                    // 创建会话项
                    const sessionLi = createSessionItem(sessionId, friend.friendName, '开始聊天吧！', friend.friendId);
                    const sessionList = document.getElementById('session-list');
                    
                    // 再次检查是否已存在相同好友的会话项
                    const existingSessionLi = findSessionLiByFriendId(friend.friendId);
                    if (existingSessionLi) {
                        console.log('移除重复的会话项');
                        existingSessionLi.remove();
                    }
                    
                    sessionList.insertBefore(sessionLi, sessionList.firstChild);
                    
                    // 切换到新会话
                    switchToSession(sessionId, friend.friendName);
                    
                    // 切换到会话标签页
                    document.querySelector('.tab-session').click();
                    
                    showNotification(`已创建与 ${friend.friendName} 的会话`, 'success');
                    resolve(sessionId);
                } else {
                    const errorMsg = (data && data.message) ? data.message : '服务器返回数据异常';
                    console.error('创建会话失败:', errorMsg);
                    showNotification('创建会话失败: ' + errorMsg, 'error');
                    reject(new Error(errorMsg));
                }
            },
            error: function(xhr, status, error) {
                console.error('创建会话请求失败:', error);
                showNotification('请求失败: ' + error, 'error');
                reject(error);
            }
        });
    });
}

// 显示搜索结果面板 - 修复版本
function showSearchResults() {
    const searchResultsPanel = document.getElementById('search-results-panel');
    console.log('显示搜索结果面板');
    
    // 使用CSS类控制显示，避免直接修改display
    searchResultsPanel.classList.remove('hide');
    searchResultsPanel.classList.add('show');
}

// 隐藏搜索结果面板 - 修复版本
function hideSearchResults() {
    const searchResultsPanel = document.getElementById('search-results-panel');
    console.log('隐藏搜索结果面板');
    
    searchResultsPanel.classList.remove('show');
    searchResultsPanel.classList.add('hide');
}

// 确保面板在初始化时就是隐藏状态
document.addEventListener('DOMContentLoaded', function() {
    const searchResultsPanel = document.getElementById('search-results-panel');
    if (searchResultsPanel) {
        // 强制设置隐藏状态
        searchResultsPanel.classList.add('hide');
        searchResultsPanel.classList.remove('show');
    }
});

// 显示搜索错误
function displaySearchError() {
    const searchResultsList = document.getElementById('search-results-list');
    
    searchResultsList.innerHTML = `
        <div class="no-results">
            <i class="fas fa-exclamation-triangle" style="margin-right: 8px;"></i>
            搜索失败，请重试
        </div>
    `;
    
    showSearchResults();
}

// 会话创建锁 - 防止同时创建多个相同好友的会话
const sessionCreationLocks = new Map();

// 带锁的会话创建函数
function createSessionWithLock(friend) {
    const lockKey = `friend_${friend.friendId}`;
    
    // 如果已经有正在创建的会话，直接返回
    if (sessionCreationLocks.has(lockKey)) {
        console.log('会话正在创建中，跳过重复请求');
        return Promise.resolve(sessionCreationLocks.get(lockKey));
    }
    
    // 设置锁
    const creationPromise = actuallyCreateNewSession(friend);
    sessionCreationLocks.set(lockKey, creationPromise);
    
    // 清理锁
    creationPromise.finally(() => {
        sessionCreationLocks.delete(lockKey);
    });
    
    return creationPromise;
}
////////////////////////////////////////////
// 添加缺失的 initInputAndSend 函数
////////////////////////////////////////////

function initInputAndSend() {
    console.log('初始化输入框和发送功能...');
    
    let messageInput = document.getElementById('message-input');
    let sendBtn = document.getElementById('send-btn');
    let messageShow = document.getElementById('message-show');
    
    if (!messageInput || !sendBtn) {
        console.error('输入框或发送按钮元素未找到');
        return;
    }
    
    console.log('找到输入框和发送按钮');
    
    // 确保输入框初始状态正确
    messageInput.disabled = true;
    messageInput.placeholder = "选择一个会话开始聊天...";
    sendBtn.disabled = true;
    
    // 修复发送按钮点击事件
    sendBtn.addEventListener('click', function(e) {
        e.preventDefault();
        sendMessage();
    });
    
    // 修复输入框键盘事件
    messageInput.addEventListener('keydown', function(e) {
        if (e.key === 'Enter' && !e.shiftKey) {
            e.preventDefault();
            sendMessage();
        }
    });
    
    // 修复输入框输入事件
    messageInput.addEventListener('input', function() {
        let hasText = this.value.trim().length > 0;
        let isEnabled = !this.disabled;
        sendBtn.disabled = !hasText || !isEnabled;
    });
    
    // 点击消息区域时聚焦输入框
    if (messageShow) {
        messageShow.addEventListener('click', function() {
            if (!messageInput.disabled) {
                messageInput.focus();
            }
        });
    }
    
    console.log('输入框和发送功能初始化完成');
}

////////////////////////////////////////////
// 加载动画控制
////////////////////////////////////////////

function showLoadingScreen() {
    document.getElementById('loadingScreen').style.display = 'flex';
}

function hideLoadingScreen() {
    document.getElementById('loadingScreen').style.display = 'none';
}


//设置一个点击事件

// 修改 clickSession 函数
function clickSession(currentLi) {
    // 1. 设置会话高亮
    let allLis = document.querySelectorAll('#session-list>li');
    activeSession(allLis, currentLi);
    
    // 2. 获取指定会话的历史消息
    let sessionId = currentLi.getAttribute("message-session-id") || currentLi.getAttribute("data-session-id");
    
    // 3. 获取用户名
    let userName = currentLi.querySelector('.name').textContent;
    
    // 4. 激活对应的好友项
    let friendId = currentLi.getAttribute('data-friend-id');
    if (friendId) {
        setActiveFriend(friendId);
    }
    
    // 5. 切换到会话
    switchToSession(sessionId, userName);
    getHistoryMessage(sessionId);
}


function activeSession(allLis, currentLi) {
    for (let li of allLis) {
        if (li == currentLi) {
            li.classList.add('active');
        } else {
            li.classList.remove('active');
        }
    }
}


////////////////////////////////////////////
// 标签页切换功能
////////////////////////////////////////////

function initSwitchTab() {
    let tabSession = document.querySelector('.tab .tab-session');
    let tabFriend = document.querySelector('.tab .tab-friend');
    let sessionList = document.getElementById('session-list');
    let friendList = document.getElementById('friend-list');

    tabSession.addEventListener('click', function() {
        // 添加active类，移除好友标签的active类
        tabSession.classList.add('active');
        tabFriend.classList.remove('active');
        
        // 显示会话列表，隐藏好友列表
        sessionList.classList.remove('hide');
        friendList.classList.add('hide');
    });

    tabFriend.addEventListener('click', function() {
        // 添加active类，移除会话标签的active类
        tabFriend.classList.add('active');
        tabSession.classList.remove('active');
        
        // 显示好友列表，隐藏会话列表
        friendList.classList.remove('hide');
        sessionList.classList.add('hide');
        
        // 刷新好友列表
        getFriendList();
    });
}


////////////////////////////////////////////
// WebSocket 连接和消息处理
////////////////////////////////////////////


////////////////////////////////////////////
// 修复输入框焦点问题
////////////////////////////////////////////

function initInputFocus() {
    let messageInput = document.getElementById('message-input');
    let messageShow = document.getElementById('message-show');
    
    // 点击消息显示区域时聚焦输入框
    messageShow.addEventListener('click', function() {
        if (!messageInput.disabled) {
            messageInput.focus();
        }
    });
    
    // 输入框获得焦点时确保光标可见
    messageInput.addEventListener('focus', function() {
        this.style.caretColor = '#7eb3b7';
    });
    
    // 修复发送按钮状态
    messageInput.addEventListener('input', function() {
        let sendBtn = document.getElementById('send-btn');
        sendBtn.disabled = !this.value.trim() || this.disabled;
    });
}

// 修改 switchToSession 函数，确保会话ID格式一致
function switchToSession(sessionId, userName) {
    // 防止重复切换会话
    if (isSwitchingSession) {
        console.log('正在切换会话，跳过重复操作');
        return;
    }
    
    isSwitchingSession = true;
    
    try {
        console.log('切换到会话:', sessionId, userName);
        
        // 确保会话ID是字符串格式
        let sessionIdStr = sessionId.toString();
        currentSessionId = sessionIdStr;
        
        // 添加到现有会话集合
        existingSessions.add(sessionIdStr);
        
        // 更新聊天标题 - 确保函数存在
        if (typeof updateChatTitle === 'function') {
            updateChatTitle(userName);
        } else {
            console.error('updateChatTitle 函数未定义');
            // 临时解决方案
            let chatTitle = document.getElementById('chat-title');
            if (chatTitle) {
                chatTitle.innerHTML = `<span>与 ${userName} 的对话</span>`;
            }
        }
        
        // 激活当前会话项
        let allSessions = document.querySelectorAll('#session-list li');
        allSessions.forEach(session => {
            session.classList.remove('active');
        });
        
        let currentSession = findSessionLi(sessionIdStr);
        if (currentSession) {
            currentSession.classList.add('active');
            
            // 清除未读消息标记
            clearUnreadBadge(sessionIdStr);
        }
        
        // 启用消息输入框
        let messageInput = document.getElementById('message-input');
        let sendBtn = document.getElementById('send-btn');
        
        messageInput.disabled = false;
        messageInput.placeholder = `发送消息给 ${userName}...`;
        messageInput.focus();
        
        sendBtn.disabled = !messageInput.value.trim();
        
        // 获取历史消息
        getHistoryMessage(sessionIdStr);
        
    } catch (error) {
        console.error('切换会话时出错:', error);
    } finally {
        isSwitchingSession = false;
    }
}



////////////////////////////////////////////
// 增强 WebSocket 连接稳定性
////////////////////////////////////////////

function initWebSocket() {
    try {
        // 创建 WebSocket 连接
        websocket = new WebSocket("ws://" + location.host + "/WebSocketMessage");
        console.log("正在创建 WebSocket 连接...");

        websocket.onopen = function(event) {
            console.log("WebSocket 连接成功!", event);
            isConnected = true;
            
        };

        websocket.onmessage = function(event) {
            console.log("收到 WebSocket 消息: ", event.data);
            try {
                let resp = JSON.parse(event.data);
                
                if (resp.type === 'message') {
                    handleMessage(resp);
                } else if (resp.type === 'friend_request') {
                    handleFriendRequest(resp);
                } else if (resp.type === 'friend_request_response') {
                    handleFriendRequestResponse(resp);
                } else if (resp.type === 'ping') {
                    // 响应心跳
                    websocket.send(JSON.stringify({type: 'pong'}));
                } else if (resp.type === 'error') {
                    console.error('WebSocket 错误:', resp.message);
                    showNotification('服务器错误: ' + resp.message, 'error');
                } else {
                    console.log("未知的消息类型: " + resp.type, resp);
                }
            } catch (error) {
                console.error('解析 WebSocket 消息失败:', error, '原始数据:', event.data);
            }
        };

        websocket.onclose = function(event) {
            console.log("WebSocket 连接关闭!", {
                code: event.code,
                reason: event.reason,
                wasClean: event.wasClean
            });
            isConnected = false;
            
            // 根据关闭代码决定重连策略
            if (event.code !== 1000) { // 1000 是正常关闭
                console.log('连接异常关闭，3秒后尝试重新连接...');
                setTimeout(initWebSocket, 3000);
            }
        };

        websocket.onerror = function(error) {
            console.log("WebSocket 连接异常!", error);
            isConnected = false;
        };
        
    } catch (error) {
        console.error('创建 WebSocket 连接失败:', error);
        setTimeout(initWebSocket, 5000); // 5秒后重试
    }
}

// 修改认证消息格式
function sendWebSocketAuth() {
    if (websocket && websocket.readyState === WebSocket.OPEN && currentUser) {
        // 如果后端不支持认证消息，完全移除这个函数调用
        console.log('跳过认证消息发送，因为后端不支持');
        return;
        
        // 如果后端支持认证，使用正确的格式（根据后端期望调整）
        // let authMessage = {
        //     type: 'auth',
        //     // 只包含后端认识的字段
        // };
        // websocket.send(JSON.stringify(authMessage));
        // console.log('发送 WebSocket 认证信息');
    }
}

// 修改 handleMessage 函数，确保正确处理服务器返回的消息
function handleMessage(resp) {
    console.log('处理收到的消息:', resp);
    
    // 检查消息是否包含必要的字段
    if (!resp.sessionId || !resp.content) {
        console.error('消息格式错误，缺少必要字段:', resp);
        return;
    }
    
    // 重要：检查消息是否来自自己，如果是则跳过会话创建
    if (resp.fromId === currentUser.userId) {
        console.log('收到自己发送的消息，跳过会话创建');
        
        // 如果当前正在查看这个会话，则显示消息
        if (currentSessionId === resp.sessionId.toString()) {
            displayMessage(resp);
            scrollToBottom();
        }
        return;
    }
    
    // 更新会话列表中的最后一条消息
    let sessionIdStr = resp.sessionId.toString();
    let sessionLi = findSessionLi(sessionIdStr);
    let currentTime = new Date();
    
    if (!sessionLi) {
        console.log('创建新会话项，消息来自:', resp.fromName);
        // 创建新的会话项 - 确保使用正确的用户名
        let displayName = resp.fromName || '未知用户';
        sessionLi = createSessionItem(sessionIdStr, displayName, resp.content, resp.fromId);
        let sessionList = document.getElementById('session-list');
        sessionList.insertBefore(sessionLi, sessionList.firstChild);
        
        // 存储会话信息
        sessions.set(sessionIdStr, {
            sessionId: sessionIdStr,
            userName: displayName,
            friendId: resp.fromId,
            lastMessage: resp.content,
            lastMessageTime: currentTime
        });
        
        // 重新排序会话列表
        reorderSessionList();
    } else {
        // 更新最后一条消息和时间
        updateLastMessage(sessionLi, resp.content);
        
        // 更新存储的会话信息
        let sessionInfo = sessions.get(sessionIdStr);
        if (sessionInfo) {
            sessionInfo.lastMessage = resp.content;
            sessionInfo.lastMessageTime = currentTime;
        }
        
        // 重新排序会话列表
        reorderSessionList();
    }

    // 如果当前正在查看这个会话，则显示消息
    if (currentSessionId === sessionIdStr) {
        displayMessage(resp);
        scrollToBottom();
    } else {
        // 显示未读消息提示 - 只在具体会话项上显示
        showUnreadBadge(sessionLi);
    }
}


function handleFriendRequest(resp) {
    // 显示好友请求通知
    showFriendRequestNotification(resp);
}

function handleFriendRequestResponse(resp) {
    if (resp.accepted) {
        // 好友请求被接受，刷新好友列表
        getFriendList();
        showNotification('好友请求已接受', 'success');
    } else {
        showNotification('好友请求被拒绝', 'error');
    }
}

////////////////////////////////////////////
// 好友功能初始化 - 修正版
////////////////////////////////////////////

function initFriendFeatures() {
    // 使用事件委托来绑定按钮事件，防止动态创建时丢失绑定
    document.addEventListener('click', function(e) {
        // 新增好友页面按钮 - 现在打开模态框而不是跳转页面
        if (e.target.closest('#add-friend-page-btn')) {
            e.preventDefault();
            // 这个功能现在在 addFriend.js 中处理
        }
        
        // 好友申请按钮
        if (e.target.closest('#friend-requests-btn')) {
            e.preventDefault();
            showFriendRequestsModal();
        }
    });
    
    // 定期更新在线状态和未读计数
    //setInterval(updateOnlineStatus, 30000); // 每30秒更新一次
   // setInterval(updateUnreadCounts, 10000); // 每10秒更新一次
    
    // 初始更新
    //updateOnlineStatus();
    //updateUnreadCounts();
}

////////////////////////////////////////////
// 在线状态管理
////////////////////////////////////////////

// function updateOnlineStatus() {
//     // 模拟从服务器获取在线状态
//     // 实际项目中这里应该是 AJAX 请求
//     $.ajax({
//         type: 'get',
//         url: 'friendStatus', // 假设有这个API
//         success: function(body) {
//             friendOnlineStatus.clear();
//             body.forEach(friend => {
//                 friendOnlineStatus.set(friend.friendId, friend.online);
//             });
//             refreshFriendListStatus();
//         },
//         error: function() {
//             // 如果API不存在，使用模拟数据
//             simulateOnlineStatus();
//         }
//     });
// }

// function simulateOnlineStatus() {
//     // 模拟在线状态数据
//     let friendItems = document.querySelectorAll('#friend-list li');
//     friendItems.forEach(item => {
//         let friendId = item.getAttribute('data-friend-id');
//         // 随机生成在线状态（实际项目中应从服务器获取）
//         let isOnline = Math.random() > 0.3; // 70%的在线概率
//         friendOnlineStatus.set(friendId, isOnline);
//     });
//     refreshFriendListStatus();
// }

// function refreshFriendListStatus() {
//     let friendItems = document.querySelectorAll('#friend-list li');
//     friendItems.forEach(item => {
//         let friendId = item.getAttribute('data-friend-id');
//         let statusElement = item.querySelector('.friend-status');
//         let statusIndicator = item.querySelector('.status-indicator');
        
//         if (!statusElement) {
//             statusElement = document.createElement('div');
//             statusElement.className = 'friend-status';
            
//             statusIndicator = document.createElement('div');
//             statusIndicator.className = 'status-indicator';
//             statusElement.appendChild(statusIndicator);
            
//             let statusText = document.createElement('span');
//             statusElement.appendChild(statusText);
            
//             let infoElement = item.querySelector('.info');
//             if (infoElement) {
//                 // 移除可能存在的旧状态元素
//                 let oldStatus = infoElement.querySelector('.friend-status');
//                 if (oldStatus) oldStatus.remove();
                
//                 // 在名字下面插入状态
//                 let nameElement = infoElement.querySelector('.name');
//                 if (nameElement) {
//                     nameElement.parentNode.insertBefore(statusElement, nameElement.nextSibling);
//                 }
//             }
//         }
        
//         let isOnline = friendOnlineStatus.get(friendId);
//         if (isOnline) {
//             statusIndicator.className = 'status-indicator status-online';
//             statusElement.querySelector('span').textContent = '在线';
//         } else {
//             statusIndicator.className = 'status-indicator status-offline';
//             statusElement.querySelector('span').textContent = '离线';
//         }
//     });
// }

////////////////////////////////////////////
// 未读消息和好友申请计数
////////////////////////////////////////////

function updateUnreadCounts() {
    // 更新未读消息计数
    //updateUnreadMessagesCount();
    
    // 更新好友申请计数
    updateFriendRequestsCount();
}

// function updateUnreadMessagesCount() {
//     // 从服务器获取未读消息数
//     $.ajax({
//         type: 'get',
//         url: 'unreadMessageCount',
//         success: function(body) {
//             unreadMessagesCount = body.count || 0;
//             updateSessionTabBadge();
//         },
//         error: function() {
//             // 如果API不存在，计算本地未读消息
//             calculateLocalUnreadCount();
//         }
//     });
// }

function calculateLocalUnreadCount() {
    let totalUnread = 0;
    let sessionItems = document.querySelectorAll('#session-list li');
    sessionItems.forEach(item => {
        let badge = item.querySelector('.unread-badge');
        if (badge && !badge.classList.contains('hide')) {
            totalUnread += parseInt(badge.textContent) || 0;
        }
    });
    //unreadMessagesCount = totalUnread;
    // 不更新会话标签徽章
}

function updateFriendRequestsCount() {
    // 从服务器获取好友申请数 - 使用 getFriendRequest API
    $.ajax({
        type: 'get',
        url: 'getFriendRequest',
        success: function(body) {
            friendRequestsCount = body.count || 0;
            updateFriendRequestsBadge();
        },
        error: function() {
            // 如果API不存在，使用模拟数据
            friendRequestsCount = Math.floor(Math.random() * 5); // 模拟0-4个申请
            updateFriendRequestsBadge();
        }
    });
}

// function updateSessionTabBadge() {
//     let badge = document.getElementById('session-tab-badge');
//     if (unreadMessagesCount > 0) {
//         badge.textContent = unreadMessagesCount > 99 ? '99+' : unreadMessagesCount.toString();
//         badge.classList.remove('hide');
//     } else {
//         badge.classList.add('hide');
//     }
// }

// 在 updateFriendRequestsBadge 函数中确保角标显示正确
function updateFriendRequestsBadge() {
    let badge = document.getElementById('friend-requests-badge');
    if (!badge) {
        console.log('好友请求徽章元素未找到');
        return;
    }
    
    if (friendRequestsCount > 0) {
        badge.textContent = friendRequestsCount > 99 ? '99+' : friendRequestsCount.toString();
        badge.classList.remove('hide');
        
        // 添加角标显示动画
        badge.style.animation = 'none';
        setTimeout(() => {
            badge.style.animation = 'pulse 2s infinite';
        }, 10);
    } else {
        badge.classList.add('hide');
    }
}

////////////////////////////////////////////
// 好友申请模态框
////////////////////////////////////////////

function showFriendRequestsModal() {
    let modal = document.getElementById('friend-requests-modal');
    let list = document.getElementById('friend-requests-list');
    
    // 清空现有列表
    list.innerHTML = '';
    
    // 模拟好友申请数据
    const mockRequests = [
        { id: 1, name: '张三', time: '2分钟前' },
        { id: 2, name: '李四', time: '5分钟前' },
        { id: 3, name: '王五', time: '1小时前' }
    ].slice(0, friendRequestsCount); // 只显示实际数量的申请
    
    if (mockRequests.length === 0) {
        list.innerHTML = '<div class="no-requests">暂无好友申请</div>';
    } else {
        mockRequests.forEach(request => {
            let requestDiv = document.createElement('div');
            requestDiv.className = 'friend-request';
            requestDiv.innerHTML = `
                <div class="avatar">${request.name.charAt(0)}</div>
                <div class="info">
                    <div class="name">${request.name}</div>
                    <div class="time">${request.time}</div>
                </div>
                <div class="actions">
                    <button class="btn btn-primary accept-request" data-request-id="${request.id}">接受</button>
                    <button class="btn btn-secondary reject-request" data-request-id="${request.id}">拒绝</button>
                </div>
            `;
            list.appendChild(requestDiv);
        });
        
        // 绑定按钮事件
        document.querySelectorAll('.accept-request').forEach(btn => {
            btn.addEventListener('click', function() {
                let requestId = this.getAttribute('data-request-id');
                handleFriendRequestResponse(requestId, true);
            });
        });
        
        document.querySelectorAll('.reject-request').forEach(btn => {
            btn.addEventListener('click', function() {
                let requestId = this.getAttribute('data-request-id');
                handleFriendRequestResponse(requestId, false);
            });
        });
    }
    
    modal.classList.remove('hide');
}

function handleFriendRequestResponse(requestId, accepted) {
    // 发送响应到服务器
    let message = {
        type: 'friend_request_response',
        requestId: requestId,
        accepted: accepted
    };
    
    if (websocket && websocket.readyState === WebSocket.OPEN) {
        websocket.send(JSON.stringify(message));
    }
    
    // 更新本地计数
    if (accepted) {
        friendRequestsCount = Math.max(0, friendRequestsCount - 1);
        updateFriendRequestsBadge();
        showNotification('好友请求已接受', 'success');
        
        // 刷新好友列表
        getFriendList();
    } else {
        friendRequestsCount = Math.max(0, friendRequestsCount - 1);
        updateFriendRequestsBadge();
        showNotification('好友请求已拒绝', 'info');
    }
    
    // 关闭模态框
    document.getElementById('friend-requests-modal').classList.add('hide');
}

////////////////////////////////////////////
// 修改好友列表获取函数以包含在线状态
////////////////////////////////////////////

function getFriendList() {
    $.ajax({
        type: 'get',
        url: 'friendList',
        success: function(body) {
            let friendListUL = document.querySelector('#friend-list');
            friendListUL.innerHTML = '';
            
            for (let friend of body) {
                let li = document.createElement('li');
                li.setAttribute('data-friend-id', friend.friendId);
                
                // 获取在线状态
                let isOnline = friendOnlineStatus.get(friend.friendId) || false;
                let statusText = isOnline ? '在线' : '离线';
                let statusClass = isOnline ? 'status-online' : 'status-offline';
                
                li.innerHTML = `
                    <div class="avatar">${friend.friendName.charAt(0)}</div>
                    <div class="info">
                        <div class="name">${friend.friendName}</div>
                        <div class="friend-status">
                            <div class="status-indicator ${statusClass}"></div>
                            <span>${statusText}</span>
                        </div>
                    </div>
                `;
                
                li.addEventListener('click', function() {
                    setActiveFriend(friend.friendId);
                    startChatWithFriend(friend);
                });
                
                friendListUL.appendChild(li);
            }
            
            // 更新好友标签徽章（只显示申请数，不显示好友总数）
            updateFriendTabBadge();
        },
        error: function() {
            console.log('获取好友列表失败!');
            showNotification('获取好友列表失败', 'error');
        }
    });
}

function updateFriendTabBadge() {
    // 好友标签的徽章只显示好友申请数，不显示好友总数
    // 这个函数在 updateFriendRequestsBadge 中已经处理了
}

////////////////////////////////////////////
// 会话管理
////////////////////////////////////////////

// 修改 findSessionLi 函数，确保能正确找到会话
function findSessionLi(sessionId) {
    let sessionItems = document.querySelectorAll('#session-list li');
    let sessionIdStr = sessionId.toString();
    
    for (let item of sessionItems) {
        let itemSessionId = item.getAttribute('data-session-id') || item.getAttribute('message-session-id');
        if (itemSessionId && itemSessionId.toString() === sessionIdStr) {
            return item;
        }
    }
    return null;
}






// 通过好友ID查找会话ID - 增强版本
function findSessionByFriendId(friendId) {
    console.log('查找好友ID对应的会话:', friendId);
    
    // 遍历所有存储的会话
    for (let [sessionId, sessionInfo] of sessions) {
        console.log(`检查会话 ${sessionId}:`, sessionInfo);
        if (sessionInfo.friendId && sessionInfo.friendId.toString() === friendId.toString()) {
            console.log('找到匹配的会话:', sessionId);
            return sessionId;
        }
    }
    
    // 如果内存中没有找到，检查DOM中的会话项
    let sessionLi = findSessionLiByFriendId(friendId);
    if (sessionLi) {
        const sessionId = sessionLi.getAttribute('data-session-id');
        console.log('在DOM中找到会话:', sessionId);
        
        // 如果会话信息丢失，重新创建会话信息
        if (!sessions.has(sessionId)) {
            const userName = sessionLi.querySelector('.name').textContent;
            const lastMessage = sessionLi.querySelector('.last-message').textContent;
            sessions.set(sessionId, {
                sessionId: sessionId,
                userName: userName,
                friendId: friendId,
                lastMessage: lastMessage,
                lastMessageTime: new Date()
            });
        }
        
        return sessionId;
    }
    
    console.log('未找到好友对应的会话');
    return null;
}



function createSessionItem(sessionId, userName, lastMessage, friendId = null) {
    let li = document.createElement('li');
    li.setAttribute('data-session-id', sessionId);
    if (friendId) {
        li.setAttribute('data-friend-id', friendId);
    }
    
    // 截断过长的消息
    let displayMessage = lastMessage;
    if (displayMessage.length > 20) {
        displayMessage = displayMessage.substring(0, 20) + '...';
    }
    
    li.innerHTML = `
        <div class="avatar">${userName.charAt(0)}</div>
        <div class="info">
            <div class="name">${userName}</div>
            <div class="last-message">${displayMessage}</div>
        </div>
        <div class="unread-badge hide">0</div>
    `;
    
    li.addEventListener('click', function() {
        clickSession(li);
    });
    
    return li;
}

function updateLastMessage(sessionLi, message) {
    let lastMessageEl = sessionLi.querySelector('.last-message');
    let displayMessage = message;
    if (displayMessage.length > 20) {
        displayMessage = displayMessage.substring(0, 20) + '...';
    }
    lastMessageEl.textContent = displayMessage;
}



function showUnreadBadge(sessionLi) {
    let badge = sessionLi.querySelector('.unread-badge');
    if (!badge) {
        // 如果不存在未读徽章，创建一个
        badge = document.createElement('div');
        badge.className = 'unread-badge';
        sessionLi.appendChild(badge);
    }
    
    let currentCount = parseInt(badge.textContent) || 0;
    let newCount = currentCount + 1;
    badge.textContent = newCount > 99 ? '99+' : newCount.toString();
    badge.classList.remove('hide');
    
    console.log('更新未读消息徽章:', sessionLi, '数量:', newCount);
    
    // 只更新具体会话项的徽章，不在标签页显示总数
    // 移除对标签页徽章的更新
}

function clearUnreadBadge(sessionId) {
    let sessionLi = findSessionLi(sessionId);
    if (sessionLi) {
        let badge = sessionLi.querySelector('.unread-badge');
        if (badge) {
            badge.classList.add('hide');
            badge.textContent = '0';
        }
    }
}


////////////////////////////////////////////
// 消息发送功能
////////////////////////////////////////////

function initSendButton() {
    let sendBtn = document.getElementById('send-btn');
    let messageInput = document.getElementById('message-input');
    
    sendBtn.addEventListener('click', sendMessage);
    
    // 按Enter发送消息，Shift+Enter换行
    messageInput.addEventListener('keydown', function(e) {
        if (e.key === 'Enter' && !e.shiftKey) {
            e.preventDefault();
            sendMessage();
        }
    });
    
    // 输入框内容变化时启用/禁用发送按钮
    messageInput.addEventListener('input', function() {
        sendBtn.disabled = !this.value.trim();
    });
}

////////////////////////////////////////////
// 修复消息格式，匹配后端期望
////////////////////////////////////////////

// 完全重写 sendMessage 函数

////////////////////////////////////////////
// 修复消息重复显示问题
////////////////////////////////////////////

// 修改 sendMessage 函数，添加消息ID避免重复

function sendMessage() {
    console.log('尝试发送消息...');
    
    // 确保关键变量已定义
    if (typeof lastMessageId === 'undefined') {
        lastMessageId = 0;
        console.log('初始化 lastMessageId:', lastMessageId);
    }
    if (typeof currentSessionId === 'undefined') {
        console.error('currentSessionId 未定义，无法发送消息');
        showNotification('请先选择一个会话', 'error');
        return;
    }
    
    let messageInput = document.getElementById('message-input');
    let sendBtn = document.getElementById('send-btn');
    let content = messageInput.value.trim();
    
    if (!content) {
        console.log('消息内容为空');
        return;
    }
    
    if (!currentSessionId) {
        console.log('没有选择会话');
        showNotification('请先选择一个会话', 'error');
        return;
    }
    
    // 确保会话ID是字符串格式
    let sessionIdStr = currentSessionId.toString();
    
    // 获取当前会话信息
    let sessionInfo = sessions.get(sessionIdStr);
    if (!sessionInfo) {
        console.log('未找到会话信息');
        showNotification('会话信息错误，请重新选择会话', 'error');
        return;
    }
    
    if (!websocket || websocket.readyState !== WebSocket.OPEN) {
        console.log('WebSocket 未连接');
        showNotification('连接未就绪，请稍后重试', 'error');
        return;
    }
    
    // 生成唯一消息ID
    let messageId = 'local_' + Date.now() + '_' + (++lastMessageId);
    
    // 构造消息对象 - 严格匹配后端期望的格式
    let message = {
        type: 'message',
        sessionId: parseInt(sessionIdStr),
        content: content
    };
    
    console.log('发送消息对象:', message);
    
    try {
        // 通过WebSocket发送
        websocket.send(JSON.stringify(message));
        console.log('WebSocket发送成功');
        
        // 在本地立即显示发送的消息（标记为本地消息）
        let messageData = {
            messageId: messageId,
            fromId: currentUser.userId,
            content: content,
            sessionId: sessionIdStr,
            isSelf: true,
            timestamp: new Date().getTime(),
            isLocal: true
        };
        displayMessage(messageData);
        
        // 更新会话的最后一条消息
        updateCurrentSessionLastMessage(content);
        
        // 清空输入框
        messageInput.value = '';
        
        // 禁用发送按钮
        sendBtn.disabled = true;
        
        console.log('消息发送流程完成');
        
    } catch (error) {
        console.error('发送消息失败:', error);
        showNotification('发送失败: ' + error.message, 'error');
    }
}

// 修改 handleMessage 函数，避免重复显示
function handleMessage(resp) {
    console.log('处理收到的消息:', resp);
    
    // 检查消息是否包含必要的字段
    if (!resp.sessionId || !resp.content) {
        console.error('消息格式错误，缺少必要字段:', resp);
        return;
    }
    
    // 生成消息ID用于去重
    let messageId = resp.messageId || ('server_' + resp.sessionId + '_' + (resp.timestamp || Date.now()));
    
    // 检查是否已经显示过这条消息（通过消息ID或内容+时间戳）
    if (isMessageAlreadyDisplayed(messageId, resp)) {
        console.log('消息已显示，跳过重复处理:', messageId);
        return;
    }
    
    // 重要：检查消息是否来自自己
    if (resp.fromId === currentUser.userId) {
        console.log('收到自己发送的消息，检查是否需要处理');
        
        // 如果这是服务器确认的消息，更新本地消息状态
        if (currentSessionId === resp.sessionId.toString()) {
            // 尝试更新本地消息的时间戳
            updateLocalMessageTimestamp(resp);
        }
        return; // 不再重复显示
    }
    
    // 更新会话列表中的最后一条消息
    let sessionIdStr = resp.sessionId.toString();
    let sessionLi = findSessionLi(sessionIdStr);
    let currentTime = new Date();
    
    if (!sessionLi) {
        console.log('创建新会话项，消息来自:', resp.fromName);
        let displayName = resp.fromName || '未知用户';
        sessionLi = createSessionItem(sessionIdStr, displayName, resp.content, resp.fromId);
        let sessionList = document.getElementById('session-list');
        sessionList.insertBefore(sessionLi, sessionList.firstChild);
        
        // 存储会话信息
        sessions.set(sessionIdStr, {
            sessionId: sessionIdStr,
            userName: displayName,
            friendId: resp.fromId,
            lastMessage: resp.content,
            lastMessageTime: currentTime
        });
        
        // 重新排序会话列表
        reorderSessionList();
    } else {
        // 更新最后一条消息和时间
        updateLastMessage(sessionLi, resp.content);
        
        // 更新存储的会话信息
        let sessionInfo = sessions.get(sessionIdStr);
        if (sessionInfo) {
            sessionInfo.lastMessage = resp.content;
            sessionInfo.lastMessageTime = currentTime;
        }
        
        // 重新排序会话列表
        reorderSessionList();
    }

    // 如果当前正在查看这个会话，则显示消息
    if (currentSessionId === sessionIdStr) {
        displayMessage(resp);
        scrollToBottom();
    } else {
        // 显示未读消息提示
        showUnreadBadge(sessionLi);
    }
    
    // 记录已显示的消息
    markMessageAsDisplayed(messageId, resp);
}

// 检查消息是否已经显示过
function isMessageAlreadyDisplayed(messageId, messageData) {
    // 简单的基于消息ID的检查
    let displayedMessages = window.displayedMessages || {};
    return displayedMessages[messageId] === true;
}

// 标记消息为已显示
function markMessageAsDisplayed(messageId, messageData) {
    window.displayedMessages = window.displayedMessages || {};
    window.displayedMessages[messageId] = true;
    
    // 限制存储的消息数量，避免内存泄漏
    let keys = Object.keys(window.displayedMessages);
    if (keys.length > 100) {
        delete window.displayedMessages[keys[0]];
    }
}

// 更新本地消息的时间戳（当收到服务器确认时）
function updateLocalMessageTimestamp(serverMessage) {
    let messageShow = document.getElementById('message-show');
    let messages = messageShow.querySelectorAll('.message');
    
    // 查找对应的本地消息并更新时间戳
    for (let i = messages.length - 1; i >= 0; i--) {
        let message = messages[i];
        let contentElement = message.querySelector('.message-content');
        
        if (contentElement && contentElement.textContent === serverMessage.content) {
            let timeElement = message.querySelector('.message-time');
            if (timeElement) {
                let timestamp = serverMessage.timestamp || serverMessage.sendTime || Date.now();
                let date = new Date(timestamp);
                timeElement.textContent = date.toLocaleTimeString();
                console.log('更新本地消息时间戳:', timeElement.textContent);
            }
            break;
        }
    }
}

// 修改 HTTP 备用发送方法，确保格式正确
function sendMessageViaHTTP(content, sessionId, toUserId) {
    console.log('尝试通过HTTP发送消息');
    
    // 根据后端API调整格式
    $.ajax({
        url: '/message/send', // 确保这个URL正确
        type: 'POST',
        contentType: 'application/json',
        data: JSON.stringify({
            sessionId: parseInt(sessionId),
            content: content
            // 不要添加后端不认识的字段
        }),
        success: function(response) {
            console.log('HTTP发送消息成功:', response);
            showNotification('消息发送成功', 'success');
        },
        error: function(xhr, status, error) {
            console.error('HTTP发送消息失败:', error);
            console.log('响应状态:', xhr.status);
            console.log('响应文本:', xhr.responseText);
            showNotification('消息发送失败: ' + (xhr.responseText || error), 'error');
        }
    });
}


// 更新当前会话的最后一条消息
function updateCurrentSessionLastMessage(content) {
    let currentSession = findSessionLi(currentSessionId);
    if (currentSession) {
        updateLastMessage(currentSession, content);
        
        // 更新存储的会话信息
        let sessionInfo = sessions.get(currentSessionId);
        if (sessionInfo) {
            sessionInfo.lastMessage = content;
            sessionInfo.lastMessageTime = new Date();
        }
        
        // 重新排序会话列表
        reorderSessionList();
    }
}

////////////////////////////////////////////
// 重新排序会话列表
////////////////////////////////////////////

function reorderSessionList() {
    let sessionListUL = document.getElementById('session-list');
    let sessionsArray = Array.from(sessions.values());
    
    // 按最后消息时间倒序排序
    sessionsArray.sort((a, b) => {
        let timeA = a.lastMessageTime || new Date(0);
        let timeB = b.lastMessageTime || new Date(0);
        return new Date(timeB) - new Date(timeA);
    });
    
    // 清空当前列表
    sessionListUL.innerHTML = '';
    
    // 按新顺序重新添加会话项
    sessionsArray.forEach(sessionInfo => {
        let sessionLi = findSessionLi(sessionInfo.sessionId);
        if (!sessionLi) {
            sessionLi = createSessionItem(
                sessionInfo.sessionId, 
                sessionInfo.userName, 
                sessionInfo.lastMessage, 
                sessionInfo.friendId
            );
        }
        sessionListUL.appendChild(sessionLi);
    });
}


////////////////////////////////////////////
// 修复时间显示问题
////////////////////////////////////////////

// 修改 displayMessage 函数，正确处理时间戳
function displayMessage(messageData) {
    let messageShow = document.getElementById('message-show');
    
    // 移除欢迎消息
    let welcomeMsg = messageShow.querySelector('.welcome-message');
    if (welcomeMsg) {
        welcomeMsg.remove();
    }
    
    let messageDiv = document.createElement('div');
    messageDiv.className = 'message';
    
    // 判断消息是否为自己发送
    let isSelf = messageData.fromId === currentUser.userId || messageData.isSelf;
    if (isSelf) {
        messageDiv.classList.add('self');
    } else {
        messageDiv.classList.add('other');
    }
    
    // 添加消息ID作为数据属性，用于后续更新
    if (messageData.messageId) {
        messageDiv.setAttribute('data-message-id', messageData.messageId);
    }
    
    // 格式化时间 - 处理各种可能的时间戳字段
    let timestamp = getMessageTimestamp(messageData);
    let timeString = formatTimestamp(timestamp);
    
    messageDiv.innerHTML = `
        <div class="message-bubble">
            <div class="message-content">${escapeHtml(messageData.content)}</div>
            <div class="message-time">${timeString}</div>
        </div>
    `;
    
    messageShow.appendChild(messageDiv);
    scrollToBottom();
    
    // 记录显示的消息
    if (messageData.messageId) {
        markMessageAsDisplayed(messageData.messageId, messageData);
    }
}

// 从消息数据中提取时间戳
function getMessageTimestamp(messageData) {
    // 尝试各种可能的时间戳字段
    return messageData.timestamp || 
           messageData.sendTime || 
           messageData.time || 
           messageData.createTime || 
           (messageData.isLocal ? Date.now() : null);
}

// 格式化时间戳
function formatTimestamp(timestamp) {
    if (!timestamp) {
        return '刚刚';
    }
    
    try {
        let date = new Date(timestamp);
        
        // 检查日期是否有效
        if (isNaN(date.getTime())) {
            return '刚刚';
        }
        
        // 如果是今天，显示时间；否则显示日期
        let now = new Date();
        let isToday = date.toDateString() === now.toDateString();
        
        if (isToday) {
            return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
        } else {
            return date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
        }
    } catch (error) {
        console.error('格式化时间戳失败:', error, timestamp);
        return '刚刚';
    }
}

function escapeHtml(text) {
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

function scrollToBottom() {
    let messageShow = document.getElementById('message-show');
    messageShow.scrollTop = messageShow.scrollHeight;
}



////////////////////////////////////////////
// 用户信息管理
////////////////////////////////////////////

////////////////////////////////////////////
// 用户信息管理 - 修正版
////////////////////////////////////////////

function getUserInfo() {
    $.ajax({
        type: 'get',
        url: 'userInfo',
        success: function(body) {
            // 从服务器获取到数据
            // 校验结果是否有效
            if (body.userId && body.userId > 0) {
                // 如果结果有效，设置当前用户信息
                currentUser = {
                    userId: body.userId,
                    username: body.username,
                    avatar: ''
                };
                
                // 更新用户界面 - 修正用户名显示
                let userDiv = document.querySelector('.main .left .user');
                
                // 保留原有的SVG图标，只更新用户名
                let existingSvg = userDiv.querySelector('svg');
                let existingActions = userDiv.querySelector('.user-actions');
                
                // 清空用户区域但保留结构
                userDiv.innerHTML = '';
                
                // 重新添加SVG
                if (existingSvg) {
                    userDiv.appendChild(existingSvg);
                } else {
                    // 如果SVG不存在，重新创建（应该不会发生）
                    let svg = document.createElement('svg');
                    svg.innerHTML = `<path d="M357.353238 279.350496a278.594155 278.594155 0 0 0 93.216025 208.303966 216.636124 216.636124 0 0 0 62.144016 9.063702c119.836775 0 217.33047-97.493695 217.330471-217.330471S632.550054 61.995228 512.713279 61.995228a216.636124 216.636124 0 0 0-62.181213 9.051303 278.594155 278.594155 0 0 0-93.178828 208.303965z" fill="#515151"></path><path d="M511.969336 61.995228c119.836775 0 217.33047 97.493695 217.330471 217.33047s-97.493695 217.318071-217.330471 217.318072-217.33047-97.481296-217.33047-217.293274 97.493695-217.355269 217.33047-217.355268m0-61.995228C357.712811 0.024798 232.668436 125.069173 232.668436 279.350496S357.712811 558.626598 511.969336 558.626598s279.3009-125.044374 279.300901-279.276102S666.275458 0.024798 511.969336 0.024798z" fill="#515151"></path><path d="M918.075275 870.784969a424.208546 424.208546 0 0 0-16.961894-46.397228q-5.405984-12.399046-11.580708-24.512913a426.675956 426.675956 0 0 0-125.453543-148.007407 420.935198 420.935198 0 0 0-252.618154-83.321586 430.246881 430.246881 0 0 0-48.356278 2.715391c-166.14721 67.921972-283.181801 231.167805-283.181802 421.741135h756.007005a425.113676 425.113676 0 0 0-17.854626-122.217392z" fill="#515151"></path><path d="M238.694372 659.641623a30.997614 30.997614 0 0 1-18.598568-55.795705 482.335271 482.335271 0 0 1 35.275285-24.16574 31.001334 31.001334 0 1 1 32.73348 52.658746c-10.588785 6.583893-20.954387 13.63895-30.799229 21.078378a30.836426 30.836426 0 0 1-18.610968 6.224321zM56.527595 1023.999975a30.997614 30.997614 0 0 1-30.997614-30.997614A486.042586 486.042586 0 0 1 146.011507 672.549029a30.997614 30.997614 0 1 1 46.620411 40.854855A424.047358 424.047358 0 0 0 87.537608 993.01476a30.997614 30.997614 0 0 1-31.010013 30.985215zM967.411078 1023.999975a30.997614 30.997614 0 0 1-30.997614-30.997614 422.113107 422.113107 0 0 0-34.804121-168.627019q-5.405984-12.399046-11.580709-24.512913a426.688355 426.688355 0 0 0-125.453543-147.995008 425.287263 425.287263 0 0 0-407.035867-54.357416 30.997614 30.997614 0 1 1-22.553864-57.717557 487.146101 487.146101 0 0 1 466.514089 62.305204 487.877644 487.877644 0 0 1 143.754534 169.494953q7.067456 13.800138 13.279378 28.096237a484.319118 484.319118 0 0 1 39.912528 193.276322 30.997614 30.997614 0 0 1-31.034811 31.034811z" fill="#515151"></path>`;
                    userDiv.appendChild(svg);
                }
                
                // 创建用户名显示元素
                let userNameSpan = document.createElement('span');
                userNameSpan.className = 'user-name';
                userNameSpan.textContent = body.username;
                userDiv.appendChild(userNameSpan);
                
                // 重新添加操作按钮
                if (existingActions) {
                    userDiv.appendChild(existingActions);
                } else {
                    // 如果操作按钮不存在，重新创建
                    let actionsDiv = document.createElement('div');
                    actionsDiv.className = 'user-actions';
                    actionsDiv.innerHTML = `
                        <button class="add-friend-btn" id="add-friend-page-btn" title="新增好友">
                            <i class="fas fa-user-plus"></i>
                        </button>
                        <button class="friend-requests-btn" id="friend-requests-btn" title="好友申请">
                            <i class="fas fa-user-friends"></i>
                            <span class="notification-badge hide" id="friend-requests-badge">0</span>
                        </button>
                    `;
                    userDiv.appendChild(actionsDiv);
                    
                    // 重新绑定事件
                    document.getElementById('add-friend-page-btn').addEventListener('click', function() {
                        window.location.href = 'addFriend.html';
                    });
                    
                    document.getElementById('friend-requests-btn').addEventListener('click', function() {
                        showFriendRequestsModal();
                    });
                }
                
                // 设置用户ID属性以备后用
                userDiv.setAttribute("user-id", body.userId);
                
                // 获取好友列表和会话列表（添加错误处理）
                try {
                    getFriendList();
                    getSessionList();
                } catch (error) {
                    console.error('初始化列表失败:', error);
                }
                
                // WebSocket 连接成功后发送认证
                setTimeout(sendWebSocketAuth, 1000);

                // 新增：初始化在线状态和未读计数
                //updateOnlineStatus();
                //updateUnreadCounts();
            } else {
                // 如果结果无效，当前未登录！则跳转到登录页面
                alert("当前用户未登录!");
                location.assign('login.html');
            }
        },
        error: function(xhr, status, error) {
            console.error('获取用户信息失败:', error);
            alert('获取用户信息失败，请刷新页面重试');
        }
    });
}

////////////////////////////////////////////
// 好友列表管理
////////////////////////////////////////////

function getFriendList() {
    $.ajax({
        type: 'get',
        url: 'friendList',
        success: function(body) {
            let friendListUL = document.querySelector('#friend-list');
            friendListUL.innerHTML = '';
            
            for (let friend of body) {
                let li = document.createElement('li');
                li.setAttribute('data-friend-id', friend.friendId);
                
                li.innerHTML = `
                    <div class="avatar">${friend.friendName.charAt(0)}</div>
                    <div class="info">
                        <div class="name">${friend.friendName}</div>
                        <div class="status">在线</div>
                    </div>
                `;
                
                // 修改点击事件处理
                li.addEventListener('click', function() {
                    // 设置好友项激活状态
                    setActiveFriend(friend.friendId);
                    startChatWithFriend(friend);
                });
                
                friendListUL.appendChild(li);
            }
        },
        error: function() {
            console.log('获取好友列表失败!');
            showNotification('获取好友列表失败', 'error');
        }
    });
}

// 设置激活的好友项
function setActiveFriend(friendId) {
    // 清除所有好友的激活状态
    let allFriends = document.querySelectorAll('#friend-list li');
    allFriends.forEach(friend => {
        friend.classList.remove('active');
    });
    
    // 设置当前好友为激活状态
    let currentFriend = document.querySelector(`#friend-list li[data-friend-id="${friendId}"]`);
    if (currentFriend) {
        currentFriend.classList.add('active');
    }
}


// 修复 startChatWithFriend 函数
function startChatWithFriend(friend) {
    console.log('开始与好友聊天:', friend);
    
    // 使用统一的会话创建函数
    createOrSwitchToSession(friend);
    
    // 更新聊天标题显示当前对话的好友
    updateChatTitle(friend.friendName);
    
    // 切换到会话标签页
    document.querySelector('.tab-session').click();
}



function createNewSession(friend) {
    console.log('createNewSession 被调用，好友:', friend);
    
    // 统一使用 actuallyCreateNewSession 函数
    actuallyCreateNewSession(friend);
}

// 显示消息提示的辅助函数
function showMessage(message, type) {
    // 移除现有的提示
    $('.message-alert').remove();
    
    // 创建 alert 类名
    const alertClass = type === 'success' ? 'alert-success' : 'alert-danger';
    
    // 使用 jQuery 创建元素，避免字符串解析问题
    const $alert = $('<div>', {
        'class': 'alert ' + alertClass + ' alert-dismissible message-alert',
        'css': {
            'position': 'fixed',
            'top': '20px',
            'right': '20px',
            'z-index': '9999',
            'min-width': '200px'
        }
    });
    
    // 创建关闭按钮
    const $closeBtn = $('<button>', {
        'type': 'button',
        'class': 'close',
        'html': '&times;',
        'click': function() {
            $alert.remove();
        }
    });
    
    // 创建消息文本
    const $messageSpan = $('<span>', {
        'text': message
    });
    
    // 组装元素
    $alert.append($closeBtn).append($messageSpan);
    
    // 添加到页面
    $('body').append($alert);
    
    // 3秒后自动消失
    setTimeout(function() {
        $alert.fadeOut(300, function() {
            $(this).remove();
        });
    }, 3000);
}

////////////////////////////////////////////
// 修复会话信息存储和获取
////////////////////////////////////////////

// 修改 getSessionList 函数，确保正确存储会话信息
// 修改 getSessionList 函数，确保不会重复添加会话
// 修改 getSessionList 函数，确保不会重复添加会话
// 修复 getSessionList 函数
function getSessionList() {
    $.ajax({
        type: 'get',
        url: 'sessionList',
        success: function(body) {
            console.log('原始会话列表数据:', body);
            
            let sessionListUL = document.querySelector('#session-list');
            
            // 清空现有列表
            sessionListUL.innerHTML = '';
            
            // 清空会话存储
            sessions.clear();
            
            // 确保body是数组
            if (!Array.isArray(body)) {
                console.error('会话列表数据格式错误，期望数组，得到:', typeof body, body);
                showNotification('获取会话列表失败：数据格式错误', 'error');
                return;
            }
            
            let validSessionsCount = 0;
            
            for (let session of body) {
                // 安全检查：确保会话数据有效
                if (!session || !session.sessionId) {
                    console.warn('跳过无效的会话数据:', session);
                    continue;
                }
                
                let displayMessage = session.lastMessage || '暂无消息';
                if (displayMessage.length > 10) {
                    displayMessage = displayMessage.substring(0, 10) + '...';
                }
                
                // 处理好友信息 - 更健壮的检查
                let friendName = '未知用户';
                let friendId = null;
                
                if (session.friends && Array.isArray(session.friends) && session.friends.length > 0) {
                    let friend = session.friends[0];
                    if (friend && friend.friendId) {
                        friendName = friend.friendName || '未知用户';
                        friendId = friend.friendId;
                    }
                } else {
                    console.warn('会话缺少好友信息，使用默认值:', session);
                    // 即使缺少好友信息，也创建会话，但使用默认值
                }
                
                let sessionId = session.sessionId.toString();
                
                // 创建会话项
                let li = document.createElement('li');
                li.setAttribute('message-session-id', sessionId);
                li.setAttribute('data-session-id', sessionId);
                if (friendId) {
                    li.setAttribute('data-friend-id', friendId);
                }
                
                li.innerHTML = `
                    <div class="avatar">${friendName.charAt(0)}</div>
                    <div class="info">
                        <div class="name">${friendName}</div>
                        <div class="last-message">${displayMessage}</div>
                    </div>
                    <div class="unread-badge hide">0</div>
                `;
                
                li.addEventListener('click', function() {
                    clickSession(li);
                });
                
                // 存储会话信息
                sessions.set(sessionId, {
                    sessionId: sessionId,
                    userName: friendName,
                    friendId: friendId,
                    lastMessage: session.lastMessage || '暂无消息',
                    lastMessageTime: session.lastMessageTime || new Date()
                });
                
                sessionListUL.appendChild(li);
                validSessionsCount++;
            }
            
            console.log(`会话列表加载完成，有效会话: ${validSessionsCount}，存储的会话:`, Array.from(sessions.keys()));
            
            // 如果没有有效会话，显示提示
            if (validSessionsCount === 0) {
                sessionListUL.innerHTML = `
                    <div style="text-align: center; padding: 20px; color: #7a9a9a;">
                        <i class="fas fa-comments" style="font-size: 24px; margin-bottom: 10px;"></i>
                        <p>暂无会话</p>
                        <p style="font-size: 12px;">开始与好友聊天吧</p>
                    </div>
                `;
            }
        },
        error: function(xhr, status, error) {
            console.log('获取会话列表失败!', error);
            showNotification('获取会话列表失败', 'error');
            
            // 显示空的会话列表
            let sessionListUL = document.querySelector('#session-list');
            sessionListUL.innerHTML = `
                <div style="text-align: center; padding: 20px; color: #7a9a9a;">
                    <i class="fas fa-exclamation-triangle" style="font-size: 24px; margin-bottom: 10px;"></i>
                    <p>加载会话失败</p>
                    <p style="font-size: 12px;">请刷新页面重试</p>
                </div>
            `;
        }
    });
}


// 修改 getHistoryMessage 函数，确保正确加载历史消息
////////////////////////////////////////////
// 修复历史消息处理
////////////////////////////////////////////

// 修改 getHistoryMessage 函数，确保正确处理历史消息
function getHistoryMessage(sessionId) {
    console.log("获取历史消息 sessionId=" + sessionId);
    
    // 1. 先清空右侧列表中的已有内容
    let messageShowDiv = document.querySelector('.right .message-show');
    if (messageShowDiv) {
        messageShowDiv.innerHTML = '';
    }

    // 2. 重新设置会话的标题
    let selectedSession = document.querySelector('#session-list li.active');
    if (selectedSession) {
        let userName = selectedSession.querySelector('.name').textContent;
        // 确保 updateChatTitle 函数存在
        if (typeof updateChatTitle === 'function') {
            updateChatTitle(userName);
        } else {
            console.error('updateChatTitle 函数未定义');
            let chatTitle = document.getElementById('chat-title');
            if (chatTitle) {
                chatTitle.innerHTML = `<span>与 ${userName} 的对话</span>`;
            }
        }
    }

    // 3. 发送ajax请求给服务器，获取该会话的历史消息
    $.ajax({
        type: 'get',
        url: 'message?sessionId=' + sessionId,
        success: function(body) {
            console.log('获取到历史消息:', body);
            
            // 确保body是数组
            if (!Array.isArray(body)) {
                console.error('历史消息格式错误，期望数组，得到:', typeof body, body);
                displayWelcomeMessage();
                return;
            }
            
            if (body.length === 0) {
                console.log('没有历史消息');
                displayWelcomeMessage();
                return;
            }
            
            // 按时间排序消息（确保从旧到新）
            body.sort((a, b) => {
                let timeA = getMessageTimestamp(a) || 0;
                let timeB = getMessageTimestamp(b) || 0;
                return timeA - timeB;
            });
            
            // 清空已显示消息记录
            window.displayedMessages = {};
            
            // 显示所有历史消息
            for (let message of body) {
                // 确保消息有正确的sessionId
                if (!message.sessionId) {
                    message.sessionId = sessionId;
                }
                
                // 为历史消息生成唯一ID
                if (!message.messageId) {
                    message.messageId = 'history_' + message.sessionId + '_' + (getMessageTimestamp(message) || Date.now());
                }
                
                displayMessage(message);
            }
            
            // 滚动到底部
            scrollToBottom();
        },
        error: function(xhr, status, error) {
            console.log('获取历史消息失败!', error);
            showNotification('获取历史消息失败', 'error');
            displayWelcomeMessage();
        }
    });
}


////////////////////////////////////////////
// 辅助函数
////////////////////////////////////////////

// 更新当前会话的最后一条消息
function updateCurrentSessionLastMessage(content) {
    let currentSession = findSessionLi(currentSessionId);
    if (currentSession) {
        updateLastMessage(currentSession, content);
        
        // 更新存储的会话信息
        let sessionInfo = sessions.get(currentSessionId);
        if (sessionInfo) {
            sessionInfo.lastMessage = content;
            sessionInfo.lastMessageTime = new Date();
        }
        
        // 重新排序会话列表
        if (typeof reorderSessionList === 'function') {
            reorderSessionList();
        }
    }
}

// 转义HTML
function escapeHtml(text) {
    if (typeof text !== 'string') {
        return text;
    }
    const div = document.createElement('div');
    div.textContent = text;
    return div.innerHTML;
}

// 初始化时设置消息记录
document.addEventListener('DOMContentLoaded', function() {
    // 初始化已显示消息记录
    window.displayedMessages = {};
});

// 显示欢迎消息
function displayWelcomeMessage() {
    let messageShow = document.getElementById('message-show');
    let welcomeMsg = messageShow.querySelector('.welcome-message');
    if (!welcomeMsg) {
        welcomeMsg = document.createElement('div');
        welcomeMsg.className = 'welcome-message';
        welcomeMsg.innerHTML = `
            <div style="text-align: center; padding: 40px; color: #7a9a9a;">
                <i class="fas fa-comments" style="font-size: 60px; margin-bottom: 20px;"></i>
                <h2>开始新的对话</h2>
                <p>发送第一条消息开始聊天吧~</p>
            </div>
        `;
        messageShow.appendChild(welcomeMsg);
    }
}


////////////////////////////////////////////
// 表情面板功能
////////////////////////////////////////////
function initEmojiPanel() {
    let emojiBtn = document.getElementById('emoji-btn');
    let emojiPanel = document.getElementById('emoji-panel');
    let closeEmojiBtn = document.querySelector('.close-emoji');
    let emojiContainer = document.getElementById('emoji-container');
    
    console.log('找到的元素:', {
        emojiBtn: emojiBtn,
        emojiPanel: emojiPanel,
        closeEmojiBtn: closeEmojiBtn,
        emojiContainer: emojiContainer
    });
    
    // 表情列表
    const emojis = ['😀', '😃', '😄', '😁', '😆', '😅', '😂', '🤣', '😊', '😇', 
                   '🙂', '🙃', '😉', '😌', '😍', '🥰', '😘', '😗', '😙', '😚',
                   '😋', '😛', '😝', '😜', '🤪', '🤨', '🧐', '🤓', '😎', '🤩'];
    
    // 填充表情容器
    emojis.forEach(emoji => {
        let span = document.createElement('span');
        span.className = 'emoji';
        span.textContent = emoji;
        span.addEventListener('click', function() {
            insertEmoji(emoji);
        });
        emojiContainer.appendChild(span);
    });
    
    // 显示/隐藏表情面板
    emojiBtn.addEventListener('click', function(e) {
        e.stopPropagation(); // 阻止事件冒泡
        console.log('点击表情按钮');
        emojiPanel.classList.toggle('show');
    });
    
    // 修复关闭按钮事件监听
    closeEmojiBtn.addEventListener('click', function(e) {
        e.stopPropagation(); // 阻止事件冒泡
        console.log('点击关闭按钮');
        emojiPanel.classList.remove('show');
    });
    
    // 点击面板外部关闭表情面板
    document.addEventListener('click', function(e) {
        if (!emojiPanel.contains(e.target) && e.target !== emojiBtn && !emojiBtn.contains(e.target)) {
            emojiPanel.classList.remove('show');
        }
    });
    
    // 阻止表情面板内部的点击事件冒泡
    emojiPanel.addEventListener('click', function(e) {
        e.stopPropagation();
    });
}

function insertEmoji(emoji) {
    let messageInput = document.getElementById('message-input');
    if (!messageInput) {
        console.error('未找到消息输入框');
        return;
    }
    
    let start = messageInput.selectionStart;
    let end = messageInput.selectionEnd;
    
    messageInput.value = messageInput.value.substring(0, start) + 
                        emoji + 
                        messageInput.value.substring(end);
    
    // 移动光标到插入位置之后
    messageInput.selectionStart = messageInput.selectionEnd = start + emoji.length;
    
    // 聚焦输入框
    messageInput.focus();
    
    // 隐藏表情面板
    document.getElementById('emoji-panel').classList.remove('show');
}

// 确保在DOM加载后初始化
document.addEventListener('DOMContentLoaded', function() {
    initEmojiPanel();
});

////////////////////////////////////////////
// 文件上传功能
////////////////////////////////////////////

function initFileUpload() {
    let imageBtn = document.getElementById('image-btn');
    let fileBtn = document.getElementById('file-btn');
    let imageInput = document.getElementById('image-input');
    let fileInput = document.getElementById('file-input');
    let uploadProgress = document.getElementById('upload-progress');
    
    imageBtn.addEventListener('click', function() {
        imageInput.click();
    });
    
    fileBtn.addEventListener('click', function() {
        fileInput.click();
    });
    
    imageInput.addEventListener('change', function() {
        if (this.files.length > 0) {
            uploadFile(this.files[0], 'image');
        }
    });
    
    fileInput.addEventListener('change', function() {
        if (this.files.length > 0) {
            uploadFile(this.files[0], 'file');
        }
    });
}

function uploadFile(file, type) {
    let uploadProgress = document.getElementById('upload-progress');
    let progressFill = document.getElementById('progress-fill');
    let progressText = document.getElementById('progress-text');
    
    // 显示上传进度条
    uploadProgress.classList.add('show');
    
    // 模拟上传过程
    let progress = 0;
    let interval = setInterval(() => {
        progress += Math.random() * 10;
        if (progress >= 100) {
            progress = 100;
            clearInterval(interval);
            
            // 上传完成
            setTimeout(() => {
                uploadProgress.classList.remove('show');
                
                // 发送文件消息
                let message = {
                    type: 'message',
                    sessionId: currentSessionId,
                    content: type === 'image' ? 
                        `[图片] ${file.name}` : 
                        `[文件] ${file.name}`,
                    fileType: type,
                    fileName: file.name
                };
                
                websocket.send(JSON.stringify(message));
                
                // 如果是图片，直接在聊天中显示
                if (type === 'image') {
                    let messageData = {
                        fromId: currentUser.userId,
                        content: `<img src="${URL.createObjectURL(file)}" alt="${file.name}" style="max-width: 200px; border-radius: 8px;">`
                    };
                    displayMessage(messageData);
                }
            }, 500);
        }
        
        progressFill.style.width = progress + '%';
        progressText.textContent = `上传中: ${Math.round(progress)}%`;
    }, 200);
}

////////////////////////////////////////////
// 工具函数
////////////////////////////////////////////

function showNotification(message, type = 'info') {
    // 创建通知元素
    let notification = document.createElement('div');
    notification.className = `notification ${type}`;
    notification.textContent = message;
    
    // 添加样式
    notification.style.cssText = `
        position: fixed;
        top: 20px;
        right: 20px;
        padding: 12px 20px;
        background: ${type === 'success' ? '#7eb3b7' : type === 'error' ? '#ff6b6b' : '#cceaf2'};
        color: white;
        border-radius: 5px;
        box-shadow: 0 3px 10px rgba(0,0,0,0.2);
        z-index: 1000;
        animation: slideIn 0.3s ease-out;
    `;
    
    document.body.appendChild(notification);
    
    // 3秒后自动移除
    setTimeout(() => {
        notification.style.animation = 'slideOut 0.3s ease-in';
        setTimeout(() => {
            if (notification.parentNode) {
                notification.parentNode.removeChild(notification);
            }
        }, 300);
    }, 3000);
}

// 添加CSS动画
const style = document.createElement('style');
style.textContent = `
    @keyframes slideIn {
        from { transform: translateX(100%); opacity: 0; }
        to { transform: translateX(0); opacity: 1; }
    }
    
    @keyframes slideOut {
        from { transform: translateX(0); opacity: 1; }
        to { transform: translateX(100%); opacity: 0; }
    }
    
    .user-name {
        margin-left: 10px;
        font-weight: 600;
        color: white;
    }
`;
document.head.appendChild(style);

////////////////////////////////////////////
// 聊天标题管理
////////////////////////////////////////////

function updateChatTitle(userName) {
    let chatTitle = document.getElementById('chat-title');
    if (chatTitle) {
        chatTitle.innerHTML = `<span>与 ${userName} 的对话</span>`;
    } else {
        console.error('未找到聊天标题元素');
    }
}